package cn.amaake.magicplugin.nacos.util;

import cn.amaake.magicplugin.nacos.util.parse.DefaultJsonConfigParse;
import cn.amaake.magicplugin.nacos.util.parse.DefaultPropertiesConfigParse;
import cn.amaake.magicplugin.nacos.util.parse.DefaultXmlConfigParse;
import cn.amaake.magicplugin.nacos.util.parse.DefaultYamlConfigParse;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.ServiceLoader;

public final class ConfigParseUtils {
    private static final String LINK_CHAR = "#@#";
    private static Map<String, ConfigParse> DEFAULT_CONFIG_PARSE_MAP = new HashMap(8);
    private static Map<String, Map<String, ConfigParse>> CUSTOMER_CONFIG_PARSE_MAP = new HashMap(8);

    public ConfigParseUtils() {
    }

    public static Map<String, Object> toProperties(String context, String type) {
        if (context == null) {
            return new LinkedHashMap();
        } else {
            type = type.toLowerCase();
            if (DEFAULT_CONFIG_PARSE_MAP.containsKey(type)) {
                ConfigParse configParse = (ConfigParse)DEFAULT_CONFIG_PARSE_MAP.get(type);
                Map<String, Object> parseMap = configParse.parse(context);
                return (Map)(parseMap == null ? new HashMap() : parseMap);
            } else {
                throw new UnsupportedOperationException("Parsing is not yet supported for this type profile : " + type);
            }
        }
    }

    public static Map<String, Object> toProperties(String dataId, String group, String context, String type) {
        if (context == null) {
            return new LinkedHashMap();
        } else {
            type = type.toLowerCase();
            String configParseKey = dataId + "#@#" + group;
            if (!CUSTOMER_CONFIG_PARSE_MAP.isEmpty() && !"#@#".equals(configParseKey)) {
                if (CUSTOMER_CONFIG_PARSE_MAP.get(type) != null && !((Map)CUSTOMER_CONFIG_PARSE_MAP.get(type)).isEmpty()) {
                    if (((Map)CUSTOMER_CONFIG_PARSE_MAP.get(type)).get(configParseKey) == null) {
                        return toProperties(context, type);
                    } else if (CUSTOMER_CONFIG_PARSE_MAP.containsKey(type)) {
                        ConfigParse configParse = (ConfigParse)((Map)CUSTOMER_CONFIG_PARSE_MAP.get(type)).get(configParseKey);
                        if (configParse == null) {
                            throw new NoSuchElementException("This config can't find ConfigParse to parse");
                        } else {
                            return configParse.parse(context);
                        }
                    } else {
                        throw new UnsupportedOperationException("Parsing is not yet supported for this type profile : " + type);
                    }
                } else {
                    return toProperties(context, type);
                }
            } else {
                return toProperties(context, type);
            }
        }
    }

    static {
        DefaultJsonConfigParse jsonConfigParse = new DefaultJsonConfigParse();
        DefaultPropertiesConfigParse propertiesConfigParse = new DefaultPropertiesConfigParse();
        DefaultYamlConfigParse yamlConfigParse = new DefaultYamlConfigParse();
        DefaultXmlConfigParse xmlConfigParse = new DefaultXmlConfigParse();
        DEFAULT_CONFIG_PARSE_MAP.put(jsonConfigParse.processType().toLowerCase(), jsonConfigParse);
        DEFAULT_CONFIG_PARSE_MAP.put(propertiesConfigParse.processType().toLowerCase(), propertiesConfigParse);
        DEFAULT_CONFIG_PARSE_MAP.put(yamlConfigParse.processType().toLowerCase(), yamlConfigParse);
        DEFAULT_CONFIG_PARSE_MAP.put(xmlConfigParse.processType().toLowerCase(), xmlConfigParse);
        ServiceLoader<ConfigParse> configParses = ServiceLoader.load(ConfigParse.class);
        StringBuilder sb = new StringBuilder();
        Iterator var6 = configParses.iterator();

        while(var6.hasNext()) {
            ConfigParse configParse = (ConfigParse)var6.next();
            String type = configParse.processType().toLowerCase();
            if (!CUSTOMER_CONFIG_PARSE_MAP.containsKey(type)) {
                CUSTOMER_CONFIG_PARSE_MAP.put(type, new HashMap(1));
            }

            sb.setLength(0);
            sb.append(configParse.dataId()).append("#@#").append(configParse.group());
            if ("#@#".equals(sb.toString())) {
                DEFAULT_CONFIG_PARSE_MAP.put(type, configParse);
            } else {
                ((Map)CUSTOMER_CONFIG_PARSE_MAP.get(type)).put(sb.toString(), configParse);
            }
        }

        DEFAULT_CONFIG_PARSE_MAP = Collections.unmodifiableMap(DEFAULT_CONFIG_PARSE_MAP);
        CUSTOMER_CONFIG_PARSE_MAP = Collections.unmodifiableMap(CUSTOMER_CONFIG_PARSE_MAP);
    }
}